home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / DJINC106.ARJ / BITSTRIN.H < prev    next >
C/C++ Source or Header  |  1992-03-29  |  20KB  |  765 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Doug Lea (dl@rocky.oswego.edu)
  5.  
  6. This file is part of the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19. #ifndef _BitString_h
  20. #ifdef __GNUG__
  21. #pragma interface
  22. #endif
  23.  
  24. #define _BitString_h 1
  25.  
  26. #include <stream.h>
  27. #include <values.h>
  28.  
  29. #define BITSTRBITS   BITS(short)
  30.  
  31. struct BitStrRep
  32. {
  33.   unsigned int    len;          // length in bits
  34.   unsigned short  sz;           // allocated slots
  35.   unsigned short  s[1];         // bits start here
  36. };
  37.  
  38. extern BitStrRep*  BStr_alloc(BitStrRep*, const unsigned short*, int, int,int);
  39. extern BitStrRep*  BStr_resize(BitStrRep*, int);
  40. extern BitStrRep*  BStr_copy(BitStrRep*, const BitStrRep*);
  41. extern BitStrRep*  cmpl(const BitStrRep*, BitStrRep*);
  42. extern BitStrRep*  and(const BitStrRep*, const BitStrRep*, BitStrRep*);
  43. extern BitStrRep*  or(const BitStrRep*, const BitStrRep*, BitStrRep*);
  44. extern BitStrRep*  xor(const BitStrRep*, const BitStrRep*, BitStrRep*);
  45. extern BitStrRep*  diff(const BitStrRep*, const BitStrRep*, BitStrRep*);
  46. extern BitStrRep*  cat(const BitStrRep*, const BitStrRep*, BitStrRep*);
  47. extern BitStrRep*  cat(const BitStrRep*, unsigned int, BitStrRep*);
  48. extern BitStrRep*  lshift(const BitStrRep*, int, BitStrRep*);
  49.  
  50.  
  51. class BitString;
  52. class BitPattern;
  53.  
  54. class BitStrBit
  55. {
  56. protected:
  57.   BitString&        src;
  58.   unsigned int      pos;
  59.  
  60.  public:
  61.                     BitStrBit(BitString& v, int p);
  62.                     BitStrBit(const BitStrBit& b);
  63.                    ~BitStrBit();
  64.                     operator unsigned int() const;
  65.   int               operator =  (unsigned int b);
  66.   int               operator == (unsigned int b) const ;
  67.   int               operator != (unsigned int b) const ;
  68. };
  69.  
  70. class BitSubString
  71. {
  72.   friend class      BitString;
  73.   friend class      BitPattern;
  74.  
  75. protected:
  76.  
  77.   BitString&        S;
  78.   unsigned int      pos;
  79.   unsigned int      len;
  80.  
  81.                     BitSubString(BitString& x, int p, int l);
  82.                     BitSubString(const BitSubString& x);
  83. public:
  84.                     ~BitSubString();
  85.  
  86.   void              operator =  (const BitString&);
  87.   void              operator =  (const BitSubString&);
  88.  
  89.   int               length() const;
  90.   int               empty() const;
  91.  
  92.   int               OK() const;
  93. };
  94.  
  95. class BitString
  96. {
  97.   friend class       BitSubString;
  98.   friend class       BitPattern;
  99. protected:
  100.   BitStrRep*         rep;
  101.  
  102.   int                search(int, int, const unsigned short*, int, int) const;
  103.   int                match(int, int, int, const unsigned short*,int,int) const;
  104.   BitSubString       _substr(int first, int l);
  105.  
  106. public:
  107.  
  108. // constructors
  109.                      BitString();
  110.                      BitString(const BitString&);
  111.                      BitString(const BitSubString& y);
  112.  
  113.                     ~BitString();
  114.  
  115.   void               operator =  (unsigned int bit);
  116.   void               operator =  (const BitString& y);
  117.   void               operator =  (const BitSubString& y);
  118.  
  119. // equality & subset tests
  120.  
  121.   friend int         operator == (const BitString&, const BitString&);
  122.   friend int         operator != (const BitString&, const BitString&);
  123.   friend int         operator <  (const BitString&, const BitString&);
  124.   friend int         operator <= (const BitString&, const BitString&);
  125.   friend int         operator >  (const BitString&, const BitString&);
  126.   friend int         operator >= (const BitString&, const BitString&);
  127.  
  128. // procedural versions of operators
  129.  
  130.  
  131.   friend void        and(const BitString&, const BitString&, BitString&);
  132.   friend void        or(const BitString&, const BitString&, BitString&);
  133.   friend void        xor(const BitString&, const BitString&, BitString&);
  134.   friend void        diff(const BitString&, const BitString&, BitString&);
  135.   friend void        cat(const BitString&, const BitString&, BitString&);
  136.   friend void        cat(const BitString&, unsigned int, BitString&);
  137.   friend void        lshift(const BitString&, int, BitString&);
  138.   friend void        rshift(const BitString&, int, BitString&);
  139.  
  140.   friend void        complement(const BitString&, BitString&);
  141.  
  142.   friend int         lcompare(const BitString&, const BitString&); 
  143.  
  144. // assignment-based operators
  145. // (constuctive versions decalred inline below
  146.  
  147.   void               operator |= (const BitString&);
  148.   void               operator &= (const BitString&);
  149.   void               operator -= (const BitString&);
  150.   void               operator ^= (const BitString&);
  151.   void               operator += (const BitString&);
  152.   void               operator += (unsigned int b);
  153.   void               operator <<=(int s);
  154.   void               operator >>=(int s);
  155.  
  156.   void               complement();
  157.  
  158. // individual bit manipulation
  159.  
  160.   void               set(int pos);
  161.   void               set(int from, int to);
  162.   void               set();
  163.  
  164.   void               clear(int pos);
  165.   void               clear(int from, int to);
  166.   void               clear(); 
  167.  
  168.   void               invert(int pos);
  169.   void               invert(int from, int to);
  170.  
  171.   int                test(int pos) const;
  172.   int                test(int from, int to) const;
  173.  
  174.   void               assign(int p, unsigned int bit);
  175.  
  176. // indexing
  177.  
  178.   BitStrBit          operator [] (int pos);
  179.  
  180. // iterators
  181.  
  182.   int                first(unsigned int bit = 1) const;
  183.   int                last(unsigned int b = 1) const;
  184.  
  185.   int                next(int pos, unsigned int b = 1) const;
  186.   int                previous(int pos, unsigned int b = 1) const;
  187.  
  188. // searching & matching
  189.  
  190.   int                index(unsigned int bit, int startpos = 0) const ;      
  191.   int                index(const BitString&, int startpos = 0) const;
  192.   int                index(const BitSubString&, int startpos = 0) const;
  193.   int                index(const BitPattern&, int startpos = 0) const;
  194.  
  195.   int                contains(const BitString&) const;
  196.   int                contains(const BitSubString&) const;
  197.   int                contains(const BitPattern&) const;
  198.  
  199.   int                contains(const BitString&, int pos) const;
  200.   int                contains(const BitSubString&, int pos) const;
  201.   int                contains(const BitPattern&, int pos) const;
  202.  
  203.   int                matches(const BitString&, int pos = 0) const;
  204.   int                matches(const BitSubString&, int pos = 0) const;
  205.   int                matches(const BitPattern&, int pos = 0) const;
  206.  
  207. // BitSubString extraction
  208.  
  209.   BitSubString       at(int pos, int len);
  210.   BitSubString       at(const BitString&, int startpos = 0); 
  211.   BitSubString       at(const BitSubString&, int startpos = 0); 
  212.   BitSubString       at(const BitPattern&, int startpos = 0); 
  213.  
  214.   BitSubString       before(int pos);
  215.   BitSubString       before(const BitString&, int startpos = 0);
  216.   BitSubString       before(const BitSubString&, int startpos = 0);
  217.   BitSubString       before(const BitPattern&, int startpos = 0);
  218.  
  219.   BitSubString       after(int pos);
  220.   BitSubString       after(const BitString&, int startpos = 0);
  221.   BitSubString       after(const BitSubString&, int startpos = 0);
  222.   BitSubString       after(const BitPattern&, int startpos = 0);
  223.  
  224. // other friends & utilities
  225.  
  226.   friend BitString   common_prefix(const BitString&, const BitString&, 
  227.                                    int pos = 0);
  228.   friend BitString   common_suffix(const BitString&, const BitString&, 
  229.                                    int pos = -1);
  230.   friend BitString   reverse(const BitString&);
  231.  
  232.   void               right_trim(unsigned int bit);
  233.   void               left_trim(unsigned int bit);
  234.  
  235. // status
  236.  
  237.   int                empty() const ;
  238.   int                count(unsigned int bit = 1) const;
  239.   int                length() const;
  240.  
  241. // convertors & IO
  242.  
  243.   friend BitString   atoBitString(const char* s, char f='0', char t='1');
  244.   friend const char* BitStringtoa(const BitString&, char f='0', char t='1');
  245.  
  246.   friend BitString   shorttoBitString(unsigned short);
  247.   friend BitString   longtoBitString(unsigned long);
  248.  
  249.   friend ostream&    operator << (ostream& s, const BitString&);
  250.  
  251. // misc
  252.  
  253.   void      error(const char* msg) const;
  254.  
  255. // indirect friends
  256.  
  257.   friend const char* BitPatterntoa(const BitPattern& p, 
  258.                                   char f='0',char t='1',char x='X');
  259.   friend BitPattern  atoBitPattern(const char* s,
  260.                                   char f='0',char t='1',char x='X');
  261.  
  262.   int                OK() const;
  263. };
  264.  
  265.  
  266. class BitPattern
  267. {
  268. public:
  269.   BitString          pattern;
  270.   BitString          mask;
  271.  
  272.                      BitPattern();
  273.                      BitPattern(const BitPattern&);
  274.                      BitPattern(const BitString& p, const BitString& m);
  275.  
  276.                     ~BitPattern();
  277.  
  278.   friend const char* BitPatterntoa(const BitPattern&, char f, char t, char x);
  279.   friend BitPattern atoBitPattern(const char* s, char f,char t, char x);
  280.   friend ostream&   operator << (ostream& s, const BitPattern&);
  281.  
  282.   int               search(const unsigned short*, int, int) const;
  283.   int               match(const unsigned short* xs, int, int, int) const;
  284.  
  285.   int               OK() const;
  286. };
  287.  
  288. BitString  operator & (const BitString& x, const BitString& y);
  289. BitString  operator | (const BitString& x, const BitString& y);
  290. BitString  operator ^ (const BitString& x, const BitString& y);
  291. BitString  operator << (const BitString& x, int y);
  292. BitString  operator >> (const BitString& x, int y);
  293. BitString  operator - (const BitString& x, const BitString& y);
  294. BitString  operator + (const BitString& x, const BitString& y);
  295. BitString  operator + (const BitString& x, unsigned int y);
  296. BitString  operator ~ (const BitString& x);
  297. int operator != (const BitString& x, const BitString& y);
  298. int operator>(const BitString& x, const BitString& y);
  299. int operator>=(const BitString& x, const BitString& y);
  300.  
  301. extern BitStrRep    _nilBitStrRep;
  302. extern BitString    _nil_BitString;
  303.  
  304. // primitive bit extraction
  305.  
  306. // These must be inlined regardless of optimization.
  307.  
  308. inline int BitStr_index(int l) { return (unsigned)(l) / BITSTRBITS; }
  309.  
  310. inline int BitStr_pos(int l) { return l & (BITSTRBITS - 1); }
  311.  
  312.  
  313. // constructors & assignment
  314.  
  315. inline BitString::BitString() :rep(&_nilBitStrRep) {}
  316.  
  317. inline BitString::BitString(const BitString& x) :rep(BStr_copy(0, x.rep)) {}
  318.  
  319. inline BitString::BitString(const BitSubString& y) 
  320.    :rep (BStr_alloc(0, y.S.rep->s, y.pos, y.pos+y.len, y.len)) {}
  321.  
  322. inline BitString::~BitString()
  323. { 
  324.   if (rep != &_nilBitStrRep) delete rep;
  325. }
  326.  
  327. #if defined(__GNUG__) && !defined(NO_NRV)
  328.  
  329. inline BitString shorttoBitString(unsigned short w) return r
  330. { 
  331.   r.rep = BStr_alloc(0, &w, 0, BITSTRBITS, BITSTRBITS);
  332. }
  333.  
  334. inline BitString longtoBitString(unsigned long w) return r
  335. { 
  336.   unsigned short u[2];
  337.   u[0] = w & ((unsigned short)(~(0)));
  338.   u[1] = w >> BITSTRBITS;
  339.   r.rep = BStr_alloc(0, &u[0], 0, 2*BITSTRBITS, 2*BITSTRBITS);
  340. }
  341.  
  342. #else
  343.  
  344. inline BitString shorttoBitString(unsigned short w) 
  345. { 
  346.   BitString r; r.rep = BStr_alloc(0, &w, 0, BITSTRBITS, BITSTRBITS); return r;
  347. }
  348.  
  349. inline BitString longtoBitString(unsigned long w) 
  350. { 
  351.   BitString r;
  352.   unsigned short u[2];
  353.   u[0] = w & ((unsigned short)(~(0)));
  354.   u[1] = w >> BITSTRBITS;
  355.   r.rep = BStr_alloc(0, &u[0], 0, 2*BITSTRBITS, 2*BITSTRBITS);
  356.   return r;
  357. }
  358.  
  359. #endif
  360.  
  361. inline void BitString::operator =  (const BitString& y)
  362. { 
  363.   rep = BStr_copy(rep, y.rep);
  364. }
  365.  
  366. inline void BitString::operator = (unsigned int b)
  367. { 
  368.   unsigned short bit = b;
  369.   rep = BStr_alloc(rep, &bit, 0, 1, 1);
  370. }
  371.  
  372. inline void BitString::operator=(const BitSubString&  y)
  373. {
  374.   rep = BStr_alloc(rep, y.S.rep->s, y.pos, y.pos+y.len, y.len);
  375. }
  376.  
  377. inline BitSubString::BitSubString(const BitSubString& x) 
  378.     :S(x.S), pos(x.pos), len(x.len) {}
  379.  
  380. inline BitSubString::BitSubString(BitString& x, int p, int l)
  381.      : S(x), pos(p), len(l) {}
  382.  
  383. inline BitSubString::~BitSubString() {}
  384.  
  385. inline BitPattern::BitPattern(const BitString& p, const BitString& m)
  386.     :pattern(p), mask(m) {}
  387.  
  388. inline BitPattern::BitPattern(const BitPattern& b)
  389.     :pattern(b.pattern), mask(b.mask) {}
  390.  
  391. inline BitPattern::BitPattern() {}
  392. inline BitPattern::~BitPattern() {}
  393.  
  394.  
  395. // procedural versions of operators
  396.  
  397. inline void and(const BitString& x, const BitString& y, BitString& r)
  398. {
  399.   r.rep = and(x.rep, y.rep, r.rep);
  400. }
  401.  
  402. inline void or(const BitString& x, const BitString& y, BitString& r)
  403. {
  404.   r.rep = or(x.rep, y.rep, r.rep);
  405. }
  406.  
  407. inline void xor(const BitString& x, const BitString& y, BitString& r)
  408. {
  409.   r.rep = xor(x.rep, y.rep, r.rep);
  410. }
  411.  
  412. inline void diff(const BitString& x, const BitString& y, BitString& r)
  413. {
  414.   r.rep = diff(x.rep, y.rep, r.rep);
  415. }
  416.  
  417. inline void cat(const BitString& x, const BitString& y, BitString& r)
  418. {
  419.   r.rep = cat(x.rep, y.rep, r.rep);
  420. }
  421.  
  422. inline void cat(const BitString& x, unsigned int y, BitString& r)
  423. {
  424.   r.rep = cat(x.rep, y, r.rep);
  425. }
  426.  
  427. inline void rshift(const BitString& x, int y, BitString& r)
  428. {
  429.   r.rep = lshift(x.rep, -y, r.rep);
  430. }
  431.  
  432. inline void lshift(const BitString& x, int y, BitString& r)
  433. {
  434.   r.rep = lshift(x.rep, y, r.rep);
  435. }
  436.  
  437. inline void complement(const BitString& x, BitString& r)
  438. {
  439.   r.rep = cmpl(x.rep, r.rep);
  440. }
  441.  
  442. // operators
  443.  
  444.  
  445. inline void BitString::operator &= (const BitString& y)
  446. {
  447.   and(*this, y, *this);
  448. }
  449.  
  450.  
  451. inline void BitString::operator |= (const BitString& y)
  452. {
  453.   or(*this, y, *this);
  454. }
  455.  
  456. inline void BitString::operator ^= (const BitString& y)
  457. {
  458.   xor(*this, y, *this);
  459. }
  460.  
  461. inline void BitString::operator <<= (int y)
  462. {
  463.   lshift(*this, y, *this);
  464. }
  465.  
  466. inline void BitString::operator >>= (int y)
  467. {
  468.   rshift(*this, y, *this);
  469. }
  470.  
  471. inline void BitString::operator -= (const BitString& y)
  472. {
  473.   diff(*this, y, *this);
  474. }
  475.  
  476. inline void BitString::operator += (const BitString& y)
  477. {
  478.   cat(*this, y, *this);
  479. }
  480.  
  481. inline void BitString::operator += (unsigned int y)
  482. {
  483.   cat(*this, y, *this);
  484. }
  485.  
  486. inline void BitString::complement()
  487. {
  488.   ::complement(*this, *this);
  489. }
  490.  
  491. #if defined(__GNUG__) && !defined(NO_NRV)
  492.  
  493. inline BitString  operator & (const BitString& x, const BitString& y) return r
  494. {
  495.   and(x, y, r);
  496. }
  497.  
  498. inline BitString  operator | (const BitString& x, const BitString& y) return r
  499. {
  500.   or(x, y, r);
  501. }
  502.  
  503. inline BitString  operator ^ (const BitString& x, const BitString& y) return r
  504. {
  505.   xor(x, y, r);
  506. }
  507.  
  508. inline BitString  operator << (const BitString& x, int y) return r
  509. {
  510.   lshift(x, y, r);
  511. }
  512.  
  513. inline BitString  operator >> (const BitString& x, int y) return r
  514. {
  515.   rshift(x, y, r);
  516. }
  517.  
  518. inline BitString  operator - (const BitString& x, const BitString& y) return r
  519. {
  520.   diff(x, y, r);
  521. }
  522.  
  523. inline BitString  operator + (const BitString& x, const BitString& y) return r
  524. {
  525.   cat(x, y, r);
  526. }
  527.  
  528. inline BitString  operator + (const BitString& x, unsigned int y) return r
  529. {
  530.   cat(x, y, r);
  531. }
  532.  
  533. inline BitString  operator ~ (const BitString& x) return r
  534. {
  535.   complement(x, r);
  536. }
  537.  
  538. #else /* NO_NRV */
  539.  
  540. inline BitString  operator & (const BitString& x, const BitString& y) 
  541. {
  542.   BitString r; and(x, y, r); return r;
  543. }
  544.  
  545. inline BitString  operator | (const BitString& x, const BitString& y) 
  546. {
  547.   BitString r; or(x, y, r); return r;
  548. }
  549.  
  550. inline BitString  operator ^ (const BitString& x, const BitString& y) 
  551. {
  552.   BitString r; xor(x, y, r); return r;
  553. }
  554.  
  555. inline BitString  operator << (const BitString& x, int y) 
  556. {
  557.   BitString r; lshift(x, y, r); return r;
  558. }
  559.  
  560. inline BitString  operator >> (const BitString& x, int y) 
  561. {
  562.   BitString r; rshift(x, y, r); return r;
  563. }
  564.  
  565. inline BitString  operator - (const BitString& x, const BitString& y) 
  566. {
  567.   BitString r; diff(x, y, r); return r;
  568. }
  569.  
  570. inline BitString  operator + (const BitString& x, const BitString& y) 
  571. {
  572.   BitString r; cat(x, y, r); return r;
  573. }
  574.  
  575. inline BitString  operator + (const BitString& x, unsigned int y) 
  576. {
  577.   BitString r; cat(x, y, r); return r;
  578. }
  579.  
  580. inline BitString  operator ~ (const BitString& x) 
  581. {
  582.   BitString r; complement(x, r); return r;
  583. }
  584.  
  585. #endif
  586.  
  587. // status, matching
  588.  
  589. inline int BitString::length() const
  590. { 
  591.   return rep->len;
  592. }
  593.  
  594. inline int BitString::empty() const
  595. { 
  596.   return rep->len == 0;
  597. }
  598.  
  599. inline int BitString::index(const BitString& y, int startpos) const
  600. {   
  601.   return search(startpos, rep->len, y.rep->s, 0, y.rep->len);
  602. }
  603.  
  604. inline int BitString::index(const BitSubString& y, int startpos) const
  605. {   
  606.   return search(startpos, rep->len, y.S.rep->s, y.pos, y.pos+y.len);
  607. }
  608.  
  609. inline int BitString::contains(const BitString& y) const
  610. {   
  611.   return search(0, rep->len, y.rep->s, 0, y.rep->len) >= 0;
  612. }
  613.  
  614. inline int BitString::contains(const BitSubString& y) const
  615. {   
  616.   return search(0, rep->len, y.S.rep->s, y.pos, y.pos+y.len) >= 0;
  617. }
  618.  
  619. inline int BitString::contains(const BitString& y, int p) const
  620. {
  621.   return match(p, rep->len, 0, y.rep->s, 0, y.rep->len);
  622. }
  623.  
  624. inline int BitString::matches(const BitString& y, int p) const
  625. {
  626.   return match(p, rep->len, 1, y.rep->s, 0, y.rep->len);
  627. }
  628.  
  629. inline int BitString::contains(const BitSubString& y, int p) const
  630. {
  631.   return match(p, rep->len, 0, y.S.rep->s, y.pos, y.pos+y.len);
  632. }
  633.  
  634. inline int BitString::matches(const BitSubString& y, int p) const
  635. {
  636.   return match(p, rep->len, 1, y.S.rep->s, y.pos, y.pos+y.len);
  637. }
  638.  
  639. inline int BitString::contains(const BitPattern& r) const
  640. {
  641.   return r.search(rep->s, 0, rep->len) >= 0;
  642. }
  643.  
  644. inline int BitString::contains(const BitPattern& r, int p) const
  645. {
  646.   return r.match(rep->s, p, rep->len, 0);
  647. }
  648.  
  649. inline int BitString::matches(const BitPattern& r, int p) const
  650. {
  651.   return r.match(rep->s, p, rep->len, 1);
  652. }
  653.  
  654. inline int BitString::index(const BitPattern& r, int startpos) const
  655. {
  656.   return r.search(rep->s, startpos, rep->len);
  657. }
  658.  
  659. inline  int BitSubString::length() const
  660. { 
  661.   return len;
  662. }
  663.  
  664. inline  int BitSubString::empty() const
  665. { 
  666.   return len == 0;
  667. }
  668.  
  669. inline int operator != (const BitString& x, const BitString& y)
  670. {
  671.   return !(x == y);
  672. }
  673.  
  674. inline int operator>(const BitString& x, const BitString& y)
  675. {
  676.   return y < x;
  677. }
  678.  
  679. inline int operator>=(const BitString& x, const BitString& y)
  680. {
  681.   return y <= x;
  682. }
  683.  
  684. inline int BitString::first(unsigned int b) const
  685. {
  686.   return next(-1, b);
  687. }
  688.  
  689. inline int BitString::last(unsigned int b) const
  690. {
  691.   return previous(rep->len, b);
  692. }
  693.  
  694. inline int BitString::index(unsigned int bit, int startpos) const
  695. {
  696.   if (startpos >= 0)
  697.     return next(startpos - 1, bit);
  698.   else
  699.     return previous(rep->len + startpos + 1, bit);
  700. }
  701.  
  702. inline void BitString::right_trim(unsigned int b) 
  703. {
  704.   int nb = (b == 0)? 1 : 0;
  705.   rep = BStr_resize(rep, previous(rep->len, nb) + 1);
  706. }
  707.  
  708. inline void BitString::left_trim(unsigned int b)
  709. {
  710.   int nb = (b == 0)? 1 : 0;
  711.   int p = next(-1, nb);
  712.   rep = BStr_alloc(rep, rep->s, p, rep->len, rep->len - p);
  713. }
  714.  
  715. inline int BitString::test(int i) const
  716. {
  717.   return ((unsigned)(i) >= rep->len)? 0 : 
  718.          ((rep->s[BitStr_index(i)] & (1 << (BitStr_pos(i)))) != 0);
  719. }
  720.  
  721.  
  722. // subscripting
  723.  
  724. inline BitStrBit::BitStrBit(const BitStrBit& b) :src(b.src), pos(b.pos) {}
  725.  
  726. inline BitStrBit::BitStrBit(BitString& v, int p) :src(v), pos(p) {}
  727.  
  728. inline BitStrBit::~BitStrBit() {}
  729.  
  730. inline BitStrBit::operator unsigned int() const
  731. {
  732.   return src.test(pos);
  733. }
  734.  
  735. inline int BitStrBit::operator = (unsigned int b)
  736. {
  737.   src.assign(pos, b); return b;
  738. }
  739.  
  740. inline int BitStrBit::operator == (unsigned int b) const
  741. {
  742.   return src.test(pos) == b;
  743. }
  744.  
  745. inline int BitStrBit::operator != (unsigned int b) const
  746. {
  747.   return src.test(pos) != b;
  748. }
  749.  
  750. inline BitStrBit BitString::operator [] (int i)
  751. {
  752.   if ((unsigned)(i) >= rep->len) error("illegal bit index");
  753.   return BitStrBit(*this, i);
  754. }
  755.  
  756. inline BitSubString BitString::_substr(int first, int l)
  757. {
  758.   if (first < 0 || l <= 0 || (unsigned)(first + l) > rep->len)
  759.     return BitSubString(_nil_BitString, 0, 0) ;
  760.   else 
  761.     return BitSubString(*this, first, l);
  762. }
  763.  
  764. #endif
  765.